import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

// 固定线程数目的线程池
class MyThreadPool {
    private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();

    // 创建 n 个线程，从线程池中取任务并执行，参数 n 表示线程池的线程数目
    public MyThreadPool(int n){
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(() -> {
                try {
                    while(true) {
                        Runnable task = queue.take(); //BlockingQueue 如果没有任务，就会产生阻塞
                        task.run();
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            });

            // 其他前台线程结束，线程池也随着结束
            // 后台线程不会无限运行，而是随着主线程（前台线程）结束而终止
            t.setDaemon(true); //设置为后台线程

            // 调用 start 才执行lambda里面的逻辑. 此时有两个分支
            // 1. 线程创建 lambda表达式设置到构造方法里面，这个过程执行速度是极快的
            // 2. 执行到start产生一个新的分支，新的分支执行while(true)
            t.start();
        }
    }

    // 往线程池中添加新的任务
    public void submit(Runnable task) throws InterruptedException {
        queue.put(task);
    }
}

public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        MyThreadPool pool = new MyThreadPool(4);
        for (int i = 0; i < 1000; i++) {
            int id = i;
            pool.submit(() -> {
                Thread cur = Thread.currentThread();
                System.out.println("hello " + cur.getName() + ", " + id);
            });
        }
        // 加 sleep 确保线程池的线程有足够的时间执行完任务
        Thread.sleep(1000);
    }
}
